package com.xjggb.createMethod;

public class CreateMethod {
    static volatile boolean flag = true;
    public static void main(String[] args) {
        show9();

    }

    public static void show9(){
        // 线程默认情况下，    interrupt标记位：false
        System.out.println(Thread.currentThread().isInterrupted());
        // 执行interrupt之后，再次查看打断信息
        Thread.currentThread().interrupt();
        // interrupt标记位：ture
        System.out.println(Thread.currentThread().isInterrupted());
        // 返回当前线程，并归位为false interrupt标记位：ture
        System.out.println(Thread.interrupted());
        // 已经归位了
        System.out.println(Thread.interrupted());

        // =====================================================
        Thread t1 = new Thread(() -> {
            while(!Thread.currentThread().isInterrupted()){
                // 处理业务
                System.out.println("处理业务" );
            }
            System.out.println("t1结束");
        });
        t1.start();
        t1.interrupt();

    }

    public static void show8(){
//    线程结束
        Thread t1 = new Thread(() -> {
          while (flag){
              System.out.println("Thread.currentThread().getName() = " + Thread.currentThread().getName());
          }
            System.out.println("任务结束");
        });
        t1.start();
        flag=false;

    }

    public static void show7(){
//    线程结束
        Thread t1 = new Thread(() -> {
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        t1.start();
        t1.stop();  // 不推荐使用
        System.out.println(t1.getState());

    }

    public static void show6(){
        /*
        * JVM会在程序中没有非守护线程时，结束掉当前JVM
     主线程默认是非守护线程，如果主线程执行结束，需要查看当前JVM内是否还有非守护线程，如果没有JVM直接停止*/
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                System.out.println("t1:" + i);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t1.setDaemon(true);
        t1.start();
    }

    public static void show5(){
        /*
        * 如果在main线程中调用了t1.join()，那么main线程会进入到等待状态，需要等待t1线程全部执行完毕，在恢复到就绪状态等待CPU调度。
       如果在main线程中调用了t1.join(2000)，那么main线程会进入到等待状态，需要等待t1执行2s后，在恢复到就绪状态等待CPU调度。如果在等待期间，t1已经结束了，那么main线程自动变为就绪状态等待CPU调度。
        * */
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                System.out.println("t1:" + i);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t1.start();
        for (int i = 0; i < 10; i++) {
            System.out.println("main:" + i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (i == 1){
                try {
                    t1.join(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }


    public static void show4(){
     /** 第一个就是native修饰的，让线程转为等待状态的效果
      * 第二个是可以传入毫秒和一个纳秒的方法（如果纳秒值大于等于0.5毫秒，就给休眠的毫秒值+1。如果传入的毫秒值是0，纳秒值不为0，就休眠1毫秒）*/
        System.out.println(System.currentTimeMillis());
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(System.currentTimeMillis());
    }

    public static void show3(){
        //可以通过Thread的静态方法yield，让当前线程从运行状态转变为就绪状态。
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 100; i++) {
                if(i == 50){
                    Thread.yield();
                }
                System.out.println("t1:" + i);
            }
        });
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 100; i++) {
                System.out.println("t2:" + i);
            }
        });
        t2.start();
        t1.start();
    }


    public static void show2(){
//        java中给线程设置的优先级别有10个级别，从1~10任取一个整数。
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                System.out.println("t1:" + i);
            }
        });
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                System.out.println("t2:" + i);
            }
        });
        t1.setPriority(1);
        t2.setPriority(10);
        t2.start();
        t1.start();
    }

    public static void show1(){
        //在构建Thread对象完毕后，一定要设置一个有意义的名称，方面后期排查错误
        Thread thread = new Thread(() -> {
            System.out.println("线程名称" + Thread.currentThread().getName());
        });
        thread.setName("模块-功能-计数器");
        thread.start();
    }

}
